/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "../include/sync.h"
#include <assert.h>
#include <string.h>

#ifdef ___SYNC_ENABLED___

namespace ime_pinyin {

    Sync::Sync()
        : userdict_ ( NULL ),
          dictfile_ ( NULL ),
          last_count_ ( 0 ) {
    };

    Sync::~Sync() {
    }


    bool Sync::begin ( const char *filename ) {
        if ( userdict_ ) {
            finish();
        }
        if ( !filename ) {
            return false;
        }
        dictfile_ = strdup ( filename );
        if ( !dictfile_ ) {
            return false;
        }
        userdict_ = new UserDict();
        if ( !userdict_ ) {
            free ( dictfile_ );
            dictfile_ = NULL;
            return false;
        }
        if ( userdict_->load_dict ( ( const char * ) dictfile_, kUserDictIdStart,
                                    kUserDictIdEnd ) == false ) {
            delete userdict_;
            userdict_ = NULL;
            free ( dictfile_ );
            dictfile_ = NULL;
            return false;
        }
        userdict_->set_limit ( kUserDictMaxLemmaCount, kUserDictMaxLemmaSize, kUserDictRatio );
        return true;
    }

    int Sync::put_lemmas ( char16 *lemmas, int len ) {
        return userdict_->put_lemmas_no_sync_from_utf16le_string ( lemmas, len );
    }

    int Sync::get_lemmas ( char16 *str, int size ) {
        return userdict_->get_sync_lemmas_in_utf16le_string_from_beginning ( str, size, &last_count_ );
    }

    int Sync::get_last_got_count() {
        return last_count_;
    }

    int Sync::get_total_count() {
        return userdict_->get_sync_count();
    }

    void Sync::clear_last_got() {
        if ( last_count_ < 0 ) {
            return;
        }
        userdict_->clear_sync_lemmas ( 0, last_count_ );
        last_count_ = 0;
    }

    void Sync::finish() {
        if ( userdict_ ) {
            userdict_->close_dict();
            delete userdict_;
            userdict_ = NULL;
            free ( dictfile_ );
            dictfile_ = NULL;
            last_count_ = 0;
        }
    }

    int Sync::get_capacity() {
        UserDict::UserDictStat stat;
        userdict_->state ( &stat );
        return stat.limit_lemma_count - stat.lemma_count;
    }

}
#endif
